package com.fengkai.filepost.pdfoutstream.test;

import common.fengkai.filepost.VO.KeywordList;
import common.fengkai.filepost.VO.pdfFileInfo;
import common.fengkai.filepost.bean.ocrBean.SealInfoData;
import common.fengkai.filepost.entity.Position;
import common.fengkai.filepost.entity.Seal;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @author Fengkai
 * @creat 2022/2/15
 */
@Slf4j
public class Solution2 {
    /**
     * 开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。
     * 从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
     * 下面是一个简单的例子 如：
     * A10;S20;W10;D30;X;A1A;B10A11;;A10;
     * 处理过程：
     * 起点（0,0）
     * +   A10   =  （-10,0）
     * +   S20   =  (-10,-20)
     * +   W10  =  (-10,-10)
     * +   D30  =  (20,-10)
     * +   x    =  无效
     * +   A1A   =  无效
     * +   B10A11   =  无效
     * +  一个空 不影响
     * +   A10  =  (10,-10)
     * 结果 （10， -10）
     */
    @Test
    public void test(){
        char s = 'a';
        System.out.println(((int) s));


    }

    @Test
    public void test2(){
        String ss = "A10;S20;W10;D30;X;A1A;B10A11;;A10;";
        String[] ws = ss.split(";");
        int x =0, y=0;
        for(String s : ws){
            // 不满足题目给定坐标规则
            if(!s.matches("[WASD][0-9]{1,2}")){
                continue;
            }
            int val = Integer.valueOf(s.substring(1));
            switch(s.charAt(0)){
                case 'W':
                    y += val;
                    break;
                case 'S':
                    y -= val;
                    break;
                case 'A':
                    x -= val;
                    break;
                case 'D':
                    x += val;
                    break;
            }
        }
        System.out.println(x+","+y);
    }
    
    //描述
    //密码要求:
    //
    //1.长度超过8位
    //
    //2.包括大小写字母.数字.其它符号,以上四种至少三种
    //
    //3.不能有长度大于2的不含公共元素的子串重复 （注：其他符号不含空格或换行）
    @Test
    public void test02(){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            if (s.length() <= 8){
                System.out.println("NG");
                continue;
            }
            if (!checkMatchString(s)){
                System.out.println("NG");
                continue;
            }
            if (checkRepactString(s)){
                System.out.println("NG");
                continue;
            }
            System.out.println("OK");
        }
    }

    //判断是否有重复子串
    private boolean checkRepactString(String s){
        for (int i = 0; i < s.length() - 2; i++) {
            String substring = s.substring(i, i + 3);
            for (int j = i + 1; j < s.length() - 3; j++) {
                if (s.substring(j, j+3).equals(substring)) {
                    return  true;
                }
            }
        }
        return false;
    }

    //正则表达式判断
    private boolean checkMatchString(String s){
        int count = 0;
        Pattern p1 = Pattern.compile("[A-Z]");
        if (p1.matcher(s).find()){
            count ++;
        }
        Pattern p2 = Pattern.compile("[a-z]");
        if (p2.matcher(s).find()){
            count++;
        }
        Pattern p3 = Pattern.compile("[^a-zA-Z0-9]");
        if (p3.matcher(s).find()){
            count++;
        }
        Pattern p4 = Pattern.compile("[0-9]");
        if (p4.matcher(s).find()){
            count++;
        }
        return count>=3?true:false;
    }

    @Test
    public void testMatch(){
        System.out.println(checkMatchString("021ABC9000"));
        System.out.println("A10".matches("[A-Z]+"));
    }
    /**
     * 描述
     * 计算最少出列多少位同学，使得剩下的同学排成合唱队形
     *
     * 说明：
     *
     * N 位同学站成一排，音乐老师要请其中的 (N - K) 位同学出列，使得剩下的 K 位同学排成合唱队形。
     * 合唱队形是指这样的一种队形：设K位同学从左到右依次编号为 1，2…，K ，他们的身高分别为 T1，T2，…，TK ，   则他们的身高满足存在 i （1<=i<=K） 使得 T1<T2<......<Ti-1<Ti>Ti+1>......>TK 。
     *
     * 你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
     *
     * 注意：不允许改变队列元素的先后顺序 且 不要求最高同学左右人数必须相等
     * 请注意处理多组输入输出！
     *
     * 数据范围： 1 \le n \le 3000 \ 1≤n≤3000
     */
    @Test
    public void test03(){
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int num = in.nextInt();
            if(num<=2){
                System.out.println(0);
            }
            int[] ints=new int[num];//存储每一个数据元素
            int[] L=new int[num];//数据元素从左到右对应的最大递增子序列数
            int[] R=new int[num];//数据元素从右到左对应的最大递增子序列数
            for(int i=0;i<num;i++){//初始化各个数组数据
                ints[i]=in.nextInt();
                L[i]=1;
                R[i]=1;
            }
            for(int i=0;i<num;i++){
                for(int j=0;j<i;j++){
                  if (ints[i] > ints[j] && L[i] + 1 >L[j]){
                      L[j] =  L[i] + 1;
                  }
                }
            }
            for(int i=num-1;i>=0;i--){
                for(int j=num-1;j>i;j--){
                    if(ints[i]>ints[j]&&R[j]+1>R[i])
                        R[i]=R[j]+1;
                }
            }
            int max=0;
            for(int i=0;i<num;i++){
                if(L[i]+R[i]>max)
                    max=L[i]+R[i];
            }
            System.out.println(num-max+1);


        }
    }

    @Test
    public void test04(){
        int [] ints= new int[]{2 ,1 ,8 ,10, 3 ,6 ,9 ,8 ,7};
        int[] left_queue=new int[]{1,1,1,1,1,1,1,1,1};//数据元素从左到右对应的最大递增子序列数
        int[] right_queue=new int[]{1,1,1,1,1,1,1,1,1};//数据元素从右到左对应的最大递增子序列数
        for(int i=0;i<ints.length;i++){
            for(int j=0;j<i;j++){
                if(ints[i]>ints[j]&&left_queue[j]+1>left_queue[i])
                    left_queue[i]=left_queue[j]+1;
            }
        }
        for(int i=ints.length-1;i>=0;i--){
            for(int j=ints.length-1;j>i;j--){
                if(ints[i]>ints[j]&&right_queue[j]+1>right_queue[i])
                    right_queue[i]=right_queue[j]+1;
            }
        }
        int max=0;
        for(int i=0;i<ints.length;i++){
            if(left_queue[i]+right_queue[i]>max)
                max=left_queue[i]+right_queue[i];
        }
        System.out.println(ints.length-max+1);
    }

    // 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，
    // 渊子把更简单的密码中出现的小写字母都变成对应的数字，数字和其它的符号都不做变换，
    //声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，
    @Test
    public void test05(){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String nextLine = scanner.nextLine();
            StringBuffer stringBuffer = new StringBuffer(nextLine);
            int length = nextLine.length();
            for (int i = 0; i <= length - 1; i++) {
                 if((int)nextLine.charAt(i) >=97 && (int)nextLine.charAt(i) <= 99) {
                     stringBuffer.replace(i, i+1, String.valueOf(2));
                 }
                if((int)nextLine.charAt(i) >=100 && (int)nextLine.charAt(i) <= 102) {
                    stringBuffer.replace(i, i+1, String.valueOf(3));
                }
                if((int)nextLine.charAt(i) >=103 && (int)nextLine.charAt(i) <= 105) {
                    stringBuffer.replace(i, i+1, String.valueOf(4));
                }
                if((int)nextLine.charAt(i) >=106 && (int)nextLine.charAt(i) <= 108) {
                    stringBuffer.replace(i, i+1, String.valueOf(5));
                }
                if((int)nextLine.charAt(i) >=109 && (int)nextLine.charAt(i) <= 111) {
                    stringBuffer.replace(i, i+1, String.valueOf(6));
                }
                if((int)nextLine.charAt(i) >=112 && (int)nextLine.charAt(i) <= 115) {
                    stringBuffer.replace(i, i+1, String.valueOf(7));
                }
                if((int)nextLine.charAt(i) >=116 && (int)nextLine.charAt(i) <= 118) {
                    stringBuffer.replace(i, i+1, String.valueOf(8));
                }
                if((int)nextLine.charAt(i) >=119 && (int)nextLine.charAt(i) <= 122) {
                    stringBuffer.replace(i, i+1, String.valueOf(9));
                }

                if ((int)nextLine.charAt(i) == 90) {
                    stringBuffer.replace(i, i+1, "A");
                }

                if ((int)nextLine.charAt(i) >=65 && (int)nextLine.charAt(i) <=89){
                    char c = (char) ((int) nextLine.charAt(i) + 1);
                    stringBuffer.replace(i, i+1, String.valueOf(c).toLowerCase());
                }
            }
            System.out.println(stringBuffer);

        }
    }

    @Test
    public void testIntChar(){
        char a = 'p';
        System.out.println((int)a);
        char z = 's';
        System.out.println((int)z);
        char A = 'A';
        System.out.println((int)A);
        char Z = 'Z';
        System.out.println((int)Z);
    }

    //删除字符串中出现次数最少的字符后的字符串
    @Test
    public void test08(){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        HashMap<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            map.put(s.charAt(i) , map.getOrDefault(s.charAt(i) ,0) +1);
        }
        Optional<Integer> min = map.values().stream().min(Integer::compareTo);
        Iterator<Map.Entry<Character, Integer>> iterator1 = map.entrySet().iterator();
        while (iterator1.hasNext()){
            Map.Entry<Character, Integer> next = iterator1.next();
            if (next.getValue() == min.get()){
                 s = s.replaceAll(String.valueOf(next.getKey()), "");
            }
        }
        System.out.println(s);
    }

    @Test
    public void testMap(){
        TreeMap<Integer, List<String>> integerListTreeMap = new TreeMap<>();
        integerListTreeMap.put(8 , Arrays.asList("aasda", "cwdq", "awubhnfuiabnsujkbfia"));
        integerListTreeMap.put(5 , Arrays.asList("dafwawdsd", "eaweasd" ,"a"));
        integerListTreeMap.put(4 , Arrays.asList("easdawd", "gasdawd", "awdawfaswgawgf"));
        Iterator<Map.Entry<Integer, List<String>>> iterator = integerListTreeMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, List<String>> next = iterator.next();
            System.out.println(next.getKey());
            next.getValue().sort((o1, o2) ->o2.length() - o1.length() );
            System.out.println(Arrays.toString(new List[]{next.getValue()}));
        }
    }

    @Test
    public void testListForEach(){
        pdfFileInfo p = new pdfFileInfo();
        p.setCopies(1);
        pdfFileInfo w = new pdfFileInfo();
        w.setCopies(3);
        w.setDuplex("www");
        pdfFileInfo f = new pdfFileInfo();
        f.setCopies(3);
        f.setDuplex("fff");
        Integer it = new Integer(2);
        ArrayList<pdfFileInfo> pdfFileInfos = new ArrayList<>();
//        pdfFileInfos.add(f);
//        pdfFileInfos.add(w);
//        pdfFileInfos.add(p);
        Optional<pdfFileInfo> max = pdfFileInfos.stream().max(Comparator.comparing(pdfFileInfo::getCopies));
        System.out.println(max.isPresent());
        if (!max.isPresent()){
            System.out.println(1111);
        }
        System.out.println(max.get().getCopies());
    }

    @Test
    public void test10(){
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        String out = "";
        int count = 0;
        String a0 = "1";
        if (i == 0){
            System.out.println(1);
            return;
        }
        if (i>59 || i <0){
            return;
        }
        int left = 0;
        int right = 0;
        for (int j = 0 ; j < i ; j++) {
             left = 0;
             right = 0;

            while (left <= a0.length() - 1){
                if (  right <= a0.length() -1 && a0.charAt(left) == a0.charAt(right)){
                    count ++;
                    right ++;
                }else {
                    //记录数据
                    out += String.valueOf(count) + String.valueOf(a0.charAt(left));
                    //重置窗口
                    left = right;
                    right = left;
                    count = 0;
                }
            }
            a0 = out;
            out = "";
        }
        System.out.println(a0);

    }

    @Test
    public void test11(){
        Scanner scanner = new Scanner(System.in);
        int index = 0;
        int count = 0;
        int m = scanner.nextInt();
        if ( m <=1 || m >= 100){
            System.out.println("ERROR!");
            return;
        }
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            integers.add(i);
        }
        String s = "";
        Iterator<Integer> listiterator = integers.iterator();
        while (true){
            if (index == 100 -m +1){
                break;
            }
            while (listiterator.hasNext()) {
                ++count;
                listiterator.next();
                if (count == m) {
                    listiterator.remove();
                    index++;
                    count = 0;
                }
            }
            listiterator = integers.iterator();
        }
        while (listiterator.hasNext()) {
            s += listiterator.next().toString() + ",";
        }
        System.out.println(s.subSequence(0, s.length() -1));
    }
    @Test
    public void  testooo(){
        System.out.println(firstLastRemaining_Solution(10, 3));
    }


    public int firstLastRemaining_Solution(int n, int m) {
        if(n < 1){
            return -1;
        }
        List<Integer> list = new ArrayList<>(n);
        for (int i = 1; i <= n ; i++) {
            list.add(i);
        }
        int count = 0;
        Iterator<Integer> iterator = list.iterator();
        while (true){
            while (iterator.hasNext()){
                ++count;
                Integer next = iterator.next();
                if(list.size() == 1){
                    return list.get(0);
                }
                if(count == m){
                    System.out.println(next);
                    iterator.remove();
                    count = 0;
                }
            }
            iterator = list.iterator();
        }
    }

    @Test
    public void test12(){
        boolean check = false;
        ahahh(check);
    }
    public void ahahh(boolean check){
        if (check){
            System.out.println(11111);
        }else {
            System.out.println(22222);
        }
    }


    @Test
    public void test13(){
        Integer [] ints = {1, 56, 89, 741, 56, 98, 55};
        List<Integer> collect = Arrays.stream(ints).collect(Collectors.toList());
        int j = 0;
        out:while (true){
            Collections.shuffle(collect);
            for (int i = 0; i < collect.size() - 1; i++) {
                if (collect.get(i) > collect.get(i + 1)){
                    j ++;
                    continue out;
                }
            }
            break ;
        }
        System.out.println(collect.toString());
        System.out.println(j);

    }
}
